
function extractOutline(text) {
    const outlineRegex = /^(#{1,6})\s+(.+?)(?:\s*\{#[\w-]+\})?\s*$/gm;
    const outline = [];
    let match;

    while ((match = outlineRegex.exec(text)) !== null) {
        const level = match[1].length;
        const title = match[2].trim();

        outline.push({
            level,
            title,
            position: match.index
        });
    }

    return outline;
}

/**
 * 根据标题分割文档
 * @param {string} text - Markdown文本
 * @param {Array} outline - 文档大纲
 * @returns {Array} - 按标题分割的段落数组
 */
function splitByHeadings(text, outline) {
    if (outline.length === 0) {
        return [{
            heading: null,
            level: 0,
            content: text,
            position: 0
        }];
    }

    const sections = [];

    // 添加第一个标题前的内容（如果有）
    if (outline[0].position > 0) {
        const frontMatter = text.substring(0, outline[0].position).trim();
        if (frontMatter.length > 0) {
            sections.push({
                heading: null,
                level: 0,
                content: frontMatter,
                position: 0
            });
        }
    }

    // 分割每个标题的内容
    for (let i = 0; i < outline.length; i++) {
        const current = outline[i];
        const next = i < outline.length - 1 ? outline[i + 1] : null;

        const headingLine = text.substring(current.position).split('\n')[0];
        const startPos = current.position + headingLine.length + 1;
        const endPos = next ? next.position : text.length;

        let content = text.substring(startPos, endPos).trim();

        sections.push({
            heading: current.title,
            level: current.level,
            content: content,
            position: current.position
        });
    }

    return sections;
}

function processSections(sections, outline, minSplitLength, maxSplitLength) {
    // 预处理：将相邻的小段落合并
    const preprocessedSections = [];
    let currentSection = null;

    for (const section of sections) {
        const contentLength = section.content.trim().length;

        if (contentLength < minSplitLength && currentSection) {
            // 如果当前段落小于最小长度且有累积段落，尝试合并
            const mergedContent = `${currentSection.content}\n\n${section.heading ? `${'#'.repeat(section.level)} ${section.heading}\n` : ''}${section.content}`;

            if (mergedContent.length <= maxSplitLength) {
                // 如果合并后不超过最大长度，则合并
                currentSection.content = mergedContent;
                if (section.heading) {
                    currentSection.headings = currentSection.headings || [];
                    currentSection.headings.push({
                        heading: section.heading,
                        level: section.level,
                        position: section.position
                    });
                }
                continue;
            }
        }

        // 如果无法合并，则开始新的段落
        if (currentSection) {
            preprocessedSections.push(currentSection);
        }
        currentSection = {
            ...section,
            headings: section.heading ? [{ heading: section.heading, level: section.level, position: section.position }] : []
        };
    }

    // 添加最后一个段落
    if (currentSection) {
        preprocessedSections.push(currentSection);
    }

    const result = [];
    let accumulatedSection = null; // 用于累积小于最小分割字数的段落

    for (let i = 0; i < preprocessedSections.length; i++) {
        const section = preprocessedSections[i];
        const contentLength = section.content.trim().length;

        // 检查是否需要累积段落
        if (contentLength < minSplitLength) {
            // 如果还没有累积过段落，创建新的累积段落
            if (!accumulatedSection) {
                accumulatedSection = {
                    heading: section.heading,
                    level: section.level,
                    content: section.content,
                    position: section.position,
                    headings: [{ heading: section.heading, level: section.level, position: section.position }]
                };
            } else {
                // 已经有累积段落，将当前段落添加到累积段落中
                accumulatedSection.content += `\n\n${section.heading ? `${'#'.repeat(section.level)} ${section.heading}\n` : ''}${section.content}`;
                if (section.heading) {
                    accumulatedSection.headings.push({
                        heading: section.heading,
                        level: section.level,
                        position: section.position
                    });
                }
            }

            // 只有当累积内容达到最小长度时才处理
            const accumulatedLength = accumulatedSection.content.trim().length;
            if (accumulatedLength >= minSplitLength) {
                const summary = require('./summary').generateEnhancedSummary(accumulatedSection, outline);

                if (accumulatedLength > maxSplitLength) {
                    // 如果累积段落超过最大长度，进一步分割
                    const subSections = splitLongSection(accumulatedSection, maxSplitLength);

                    for (let j = 0; j < subSections.length; j++) {
                        result.push({
                            summary: `${summary} - Part ${j + 1}/${subSections.length}`,
                            content: subSections[j]
                        });
                    }
                } else {
                    // 添加到结果中
                    result.push({
                        summary,
                        content: accumulatedSection.content
                    });
                }

                accumulatedSection = null; // 重置累积段落
            }

            continue;
        }

        // 如果有累积的段落，先处理它
        if (accumulatedSection) {
            const summary = require('./summary').generateEnhancedSummary(accumulatedSection, outline);
            const accumulatedLength = accumulatedSection.content.trim().length;

            if (accumulatedLength > maxSplitLength) {
                // 如果累积段落超过最大长度，进一步分割
                const { result: subSections, lastChunk } = splitLongSection(accumulatedSection, maxSplitLength, minSplitLength);

                for (let j = 0; j < subSections.length; j++) {
                    result.push({
                        summary: `${summary} - Part ${j + 1}/${subSections.length}`,
                        content: subSections[j]
                    });
                }

                // 如果有未处理的小段落，保存下来等待下一次合并
                if (lastChunk) {
                    accumulatedSection = {
                        ...accumulatedSection,
                        content: lastChunk
                    };
                    continue;
                }
            } else {
                // 添加到结果中
                result.push({
                    summary,
                    content: accumulatedSection.content
                });
            }

            accumulatedSection = null; // 重置累积段落
        }

        // 处理当前段落
        // 如果段落长度超过最大分割字数，需要进一步分割
        if (contentLength > maxSplitLength) {
            const subSections = splitLongSection(section, maxSplitLength);

            // 为当前段落创建一个标准的headings数组
            if (!section.headings && section.heading) {
                section.headings = [{ heading: section.heading, level: section.level, position: section.position }];
            }

            for (let i = 0; i < subSections.length; i++) {
                const subSection = subSections[i];
                const summary = require('./summary').generateEnhancedSummary(section, outline, i + 1, subSections.length);

                result.push({
                    summary,
                    content: subSection
                });
            }
        } else {
            // 为当前段落创建一个标准的headings数组
            if (!section.headings && section.heading) {
                section.headings = [{ heading: section.heading, level: section.level, position: section.position }];
            }

            // 生成增强的摘要并添加到结果
            const summary = require('./summary').generateEnhancedSummary(section, outline);

            const content = `${section.heading ? `${'#'.repeat(section.level)} ${section.heading}\n` : ''}${section.content}`;

            result.push({
                summary,
                content,
            });
        }
    }

    // 处理最后剩余的小段落
    if (accumulatedSection && result.length > 0) {
        // 尝试将剩余的小段落与最后一个结果合并
        const lastResult = result[result.length - 1];
        const mergedContent = `${lastResult.content}\n\n${accumulatedSection.content}`;

        if (mergedContent.length <= maxSplitLength) {
            // 如果合并后不超过最大长度，则合并
            const summary = require('./summary').generateEnhancedSummary({
                ...accumulatedSection,
                content: mergedContent
            }, outline);

            result[result.length - 1] = {
                summary,
                content: mergedContent
            };
        }
    }

    return result;
}

/**
 * 分割超长段落
 * @param {Object} section - 段落对象
 * @param {number} maxSplitLength - 最大分割字数
 * @returns {Array} - 分割后的段落数组
 */
function splitLongSection(section, maxSplitLength) {
    const content = section.content;
    const paragraphs = content.split(/\n\n+/);
    const result = [];
    let currentChunk = '';

    for (const paragraph of paragraphs) {
        // 如果当前段落本身超过最大长度，可能需要进一步拆分
        if (paragraph.length > maxSplitLength) {
            // 如果当前块不为空，先加入结果
            if (currentChunk.length > 0) {
                result.push(currentChunk);
                currentChunk = '';
            }

            // 对超长段落进行分割（例如，按句子或固定长度）
            const sentenceSplit = paragraph.match(/[^.!?]+[.!?]+/g) || [paragraph];

            // 处理分割后的句子
            let sentenceChunk = '';
            for (const sentence of sentenceSplit) {
                if ((sentenceChunk + sentence).length <= maxSplitLength) {
                    sentenceChunk += sentence;
                } else {
                    if (sentenceChunk.length > 0) {
                        result.push(sentenceChunk);
                    }
                    // 如果单个句子超过最大长度，可能需要进一步拆分
                    if (sentence.length > maxSplitLength) {
                        // 简单地按固定长度分割
                        for (let i = 0; i < sentence.length; i += maxSplitLength) {
                            result.push(sentence.substr(i, maxSplitLength));
                        }
                    } else {
                        sentenceChunk = sentence;
                    }
                }
            }

            if (sentenceChunk.length > 0) {
                currentChunk = sentenceChunk;
            }
        } else if ((currentChunk + '\n\n' + paragraph).length <= maxSplitLength) {
            // 如果添加当前段落不超过最大长度，则添加到当前块
            currentChunk = currentChunk.length > 0 ? currentChunk + '\n\n' + paragraph : paragraph;
        } else {
            // 如果添加当前段落超过最大长度，则将当前块加入结果，并重新开始一个新块
            result.push(currentChunk);
            currentChunk = paragraph;
        }
    }

    // 添加最后一个块（如果有）
    if (currentChunk.length > 0) {
        result.push(currentChunk);
    }

    return result;
}

text = "# 公司产品介绍\n" +
    "\n" +
    "## 公司介绍\n" +
    "\n" +
    "1. 翼辉爱智简介\n" +
    "\n" +
    "西安翼辉爱智物联技术有限公司成立于 2019 年，隶属于翼辉集团，是一家聚焦于边缘计算领域的物联网高新技术企业。技术团队由行业一流人才组成，在操作系统、物联网、计算应用软件等领域拥有 20 余年的研发经验。公司致力于为客户提供智能边缘计算操作系统、技术服务及软硬件综合解决方案。\n" +
    "公司主要产品为面向未来的智能边缘计算操作系统 EdgerOS ，我们围绕 EdgerOS 打造了万物互联的技术生态，可以为行业厂商和开发者提供广阔的开发平台和完备的技术支持，共同推进万物互联时代的进程。未来 EdgerOS 将广泛应用于智慧家庭、智能制造、智慧汽车、智能楼宇、智慧园区、智慧城市、智慧农业等领域。\n" +
    "\n" +
    "2. 翼辉信息简介\n" +
    "\n" +
    "北京翼辉信息技术有限公司（翼辉信息）成立于 2015 年，是中国拥有大型实时操作系统完整自主知识产权的高新技术企业。技术团队拥有十年以上嵌入式系统设计经验，专注定位为嵌入式软件供应商，为行业用户提供安全智慧的嵌入式实时操作系统、技术服务及产品解决方案。 \n" +
    "\n" +
    "3. 翼辉汽车简介\n" +
    "\n" +
    "翼辉信息基于多年在基础软件领域的深厚积累，通过 SylixOS ASIL-D 功能安全操作系统、任务关键型分布式  SOA 架构（Vehicle SOA）、容器化 DevSecOps 管理平台、EdegrOS 智能边缘计算操作系统等产品，致力于打造智能网联、智能驾驶、安全车控、智能座舱、车载中央计算机等智能汽车全场景解决方案。\n" +
    "\n" +
    "4. 如何联系翼辉爱智？\n" +
    "\n" +
    "翼辉爱智提供了如下几种联系方式，请选择您需要的方式进行联系：\n" +
    "\n" +
    "商务合作：business@edgeros.com\n" +
    "\n" +
    "售后支持：support@edgeros.com\n" +
    "\n" +
    "技术支持：sales@edgeros.com\n" +
    "\n" +
    "联系电话：029-89840812\n" +
    "\n" +
    "公司地址：西安市雁塔区锦业路 中铁西安中心 12 层\n" +
    "\n" +
    "## 爱智产品介绍\n" +
    "\n" +
    "### EdgerOS 产品介绍\n" +
    "\n" +
    "1. 什么是 EdgerOS？\n" +
    "\n" +
    "EdgerOS 是翼辉自主研发的一款面向万物互联时代的智能边缘计算操作系统，部署在数据边缘，为用户提供低时延、高带宽、高安全的计算和存储服务。EdgerOS 具备自主可控、极简开发、开放生态和安全可靠等特点。它为开发者提供了基于互联网技术栈的操作系统平台，抽象了复杂的底层设备管理和通信协议，极大简化了物联网应用的开发难度。\n" +
    "\n" +
    "2. EdgerOS 有那些特点和优势？\n" +
    "\n" +
    "EdgerOS 作为一款智能边缘计算操作系统，具备以下特点：\n" +
    "\n" +
    "- 自主可控：内核自主化率 100%，拥有完全自主可控的技术能力，满足国产化需求。EdgerOS 可根据使用场景的不同，进行系统级别的整合和优化，为合作伙伴提供更加深度的技术支持，帮助用户摆脱国外系统依赖，为国家关键领域的数字化转型提供自主可控的技术底座。\n" +
    "\n" +
    "- 开放生态：通过在操作系统层面对物联网设备和服务的抽象和标准化，实现了物联网软硬件的完全解耦，不限制智能设备的厂家或者品牌，设备和应用之间可以随意组合，应用开发者和设备开发者可以随意组合，基于爱智生态，快速完成产品研发和迭代，实现互利共赢。\n" +
    "\n" +
    "- 极简开发：打通了互联网与物联网技术栈，开发者可以使用熟悉的 JavaScript 语言和 VUE 框架等互联网技术开发物联网应用；同时系统提供了功能丰富、开箱即用的开发框架和人工智能接口，开发者无需了解设备参数和网络协议等底层细节，调用相关接口就可以快速实现业务开发，极大降低了物联网应用的开发门槛，提升了开发效率。\n" +
    "\n" +
    "- 高效互联：EdgerOS 通过设备抽象完成了异构设备资源整合，提供标准和私有协议接入能力，同时从系统内核提供了对 Wi-Fi、ZigBee、LoRa 等标准物联网协议的支持和优化，可以自动发现周围设备，实现与不同品牌、不同协议物联网设备之间的高效互联互通。\n" +
    "\n" +
    "- 算力分享：内置了丰富的人工智能算法，可以根据业务需求动态分配边缘设备的算力，并将自身算力分享给与其连接的端设备，端设备不需要具备很强的算力，通过 EdgerOS 的共享算力和应用，可以赋予端设备更多智能化能力。增加设备功能的同时，降低了设备成本。\n" +
    "\n" +
    "-安全可靠：系统安全方面，EdgerOS 内核通过了操作系统最高等级 SIL3、SIL4 和 ASILD 国际安全认证。应用安全方面，EdgerOS 不仅通过安全容器沙箱技术和数字证书安全认证，对访问的安全性做到了有效防护，且支持用户-应用-设备多维权限管理，可以为物联网设备和用户隐私数据提供强大的安全保护。\n" +
    "\n" +
    "3. EdgerOS 可以应用于哪些领域？\n" +
    "\n" +
    "EdgerOS 作为万物互联时代的智能边缘计算操作系统，可广泛应用于智慧家庭、智能制造、智能汽车、智能楼宇、智慧园区、智慧城市、智慧农业等领域。\n" +
    "\n" +
    "4. EdgerOS 可以为企业带来哪些价值？\n" +
    "\n" +
    "EdgerOS 作为一个开放的智能操作系统，从高层 API 到底层 API，到 SDK 都实现开放，此外还提供开放的爱智世界软件商店，以及打造爱智开发者平台和工具等产品。“搭建好所有的基础设施服务，像积木一样供人选择”，是EdgerOS 的理念。小微企业可以通过 EdgerOS 迅速突破底层技术瓶颈，大中型企业可以通过 EdgerOS 补足技术短板，以合作共同抗衡行业变化和竞争。翼辉希望品牌、开发者、设备制造商、解决方案商，都可以参与到 EdgerOS 生态里面来，一起实现万物智能互联。\n" +
    "\n" +
    "5. EdgerOS 如何为智慧家庭赋能？\n" +
    "\n" +
    "EdgerOS 作为智慧家庭的高级大脑，能够连接和管理不同的智能设备，用户可以选择高性价比的智能设备构建自己的智慧家庭，统一操控家里的智能设备，且强大的 AI 引擎可以使不同的智能设备自动协同工作，将家中的一切都安排的妥妥的，为用户提供 7X24 小时不间断服务。\n" +
    "\n" +
    "6. EdgerOS 可以为用户带来什么样的物联网体验？\n" +
    "\n" +
    "EdgerOS 可以像手机一样安装各种应用，赋予同一个设备不同的能力，实现场景化智能，且支持多人同时使用，给用户带来一次购入、多功能享受的全新物联网体验。\n" +
    "\n" +
    "7. EdgerOS 如何保证用户隐私安全？\n" +
    "\n" +
    "EdgerOS 采用“零信任”安全机制，可以全方位保护用户的个人数据和隐私安全。\n" +
    "\n" +
    "- 始终验证：始终基于所有的数据点进行身份验证和授权，包括用户标识、应用、设备、系统能力 （网络、AI、视频）等。\n" +
    "- 最少权限：通过适时赋予用户、设备和应⽤最少权限来保护数据安全，同时不影响用户业务的正常运转。\n" +
    "- 防御性思维：默认不给予用户、设备和应用任何权限，管理员给用户、设备和应⽤明确的授权之后，用户、设备和应用才能获得相应的权限和能力，以减少对数据和系统的潜在损害。\n" +
    "\n" +
    "8. EdgerOS 提供哪些开发框架？\n" +
    "\n" +
    "EdgerOS 提供了功能丰富的开发框架，包括 App 框架、流媒体框架、AI 框架、设备管理框架。其中 App 框架提供了丰富的基础组件，降低了应用开发的复杂度；流媒体框架和 AI 框架，为开发者提供了开箱即用的人工智能接口和流媒体处理能力；设备管理框架实现了对智能设备的高度抽象和封装，开发者不需要了解智能设备的底层通信协议细节，只需要调用高度抽象的设备接口，就可以快速发现和连接设备，并调用设备的各项功能。\n" +
    "\n" +
    "9. EdgerOS 的系统架构分几层？\n" +
    "\n" +
    "EdgerOS 的整个系统架构共分为五层，从下向上分别为：内核层、JSRE、系统服务层、应用框架层和应用层。\n" +
    "\n" +
    "10. EdgerOS 可以为应用开发者提供哪些技术支持？\n" +
    "\n" +
    "- 应用开发者可直接使用 EdgerOS 提供的高性能 JSRE 和功能丰富的系统服务。\n" +
    "- EdgerOS 提供设备抽象能力，应用开发者通过爱智设备框架的标准接口即可调用硬件设备，可使用任意 Web 框架进行前后端分离开发。\n" +
    "- 功能丰富的应用框架，包括 App 框架、流媒体框架、AI 框架、设备管理框架等。\n" +
    "- 应用开发者可使用丰富的基础库和 API。\n" +
    "- 应用开发者可使用 EdgerOS 提供的安全加密、AI、多媒体、数据库和多种通信协议等核心能力。\n" +
    "- 应用开发者可直接使用爱智云提供的远程访问、应用分发、支付、消息推送等能力。\n" +
    "- 应用开发者可通过爱智实现 SDDC/ZDDC 连接。\n" +
    "- EdgerOS 提供多维度权限管理功能，支持配置用户-应用-设备间的访问权限，对系统能力进行组合。\n" +
    "\n"
outline = extractOutline(text)
// console.log(outline)

sections = splitByHeadings(text, outline)
// console.log(sections)

const res = processSections(sections, outline, 1000, 2000);
// console.log(res)

final_result = res.map(r => ({
    result: `> **📑 Summarization：** *${r.summary}*\n\n---\n\n${r.content}`,
    ...r,
}))
console.log(final_result)

